home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / OWLSRC.PAK / CONTAIN.CPP < prev    next >
C/C++ Source or Header  |  1997-05-06  |  6KB  |  502 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectWindows
  3. // Copyright (c) 1993, 1997 by Borland International, All Rights Reserved
  4. //
  5. //$Revision:   10.5  $
  6. //
  7. // Implementation of many of OWL's container classes
  8. //----------------------------------------------------------------------------
  9. #include <owl/pch.h>
  10. #if !defined(OWL_CONTAIN_H)
  11. # include <owl/contain.h>
  12. #endif
  13.  
  14. OWL_DIAGINFO;
  15.  
  16. //
  17. //
  18. //
  19. TStringArray::TStringArray(int upper, int lower, int delta)
  20. :
  21.   Data(upper, lower, delta)
  22. {
  23. }
  24.  
  25. //
  26. //
  27. //
  28. int TStringArray::LowerBound() const
  29. {
  30.   return Data.LowerBound();
  31. }
  32.  
  33. //
  34. //
  35. //
  36. int TStringArray::UpperBound() const
  37. {
  38.   return Data.UpperBound();
  39. }
  40.  
  41. //
  42. //
  43. //
  44. unsigned TStringArray::ArraySize() const
  45. {
  46.   return Data.ArraySize();
  47. }
  48.  
  49. //
  50. //
  51. //
  52. int TStringArray::IsFull() const
  53. {
  54.   return Data.IsFull();
  55. }
  56.  
  57. //
  58. //
  59. //
  60. int TStringArray::IsEmpty() const
  61. {
  62.   return Data.IsEmpty();
  63. }
  64.  
  65. //
  66. //
  67. //
  68. unsigned TStringArray::GetItemsInContainer() const
  69. {
  70.   return Data.GetItemsInContainer();
  71. }
  72.  
  73. //
  74. //
  75. //
  76. int TStringArray::Add(const string& t)
  77. {
  78.   return Data.Add(t);
  79. }
  80.  
  81. //
  82. //
  83. //
  84. int TStringArray::Detach(const string& t)
  85. {
  86.   return Data.Detach(t);
  87. }
  88.  
  89. //
  90. //
  91. //
  92. int TStringArray::Detach(int loc)
  93. {
  94.   return Data.Detach(loc);
  95. }
  96.  
  97. //
  98. //
  99. //
  100. int TStringArray::Destroy(const string& t)
  101. {
  102.   return Detach(t);
  103. }
  104.  
  105. //
  106. //
  107. //
  108. int TStringArray::Destroy(int loc)
  109. {
  110.   return Detach(loc);
  111. }
  112.  
  113. //
  114. //
  115. //
  116. int TStringArray::HasMember(const string& t) const
  117. {
  118.   return Data.HasMember(t);
  119. }
  120.  
  121. //
  122. //
  123. //
  124. int TStringArray::Find(const string& t) const
  125. {
  126.   return Data.Find(t);
  127. }
  128.  
  129. //
  130. //
  131. //
  132. string& TStringArray::operator [](int loc)
  133. {
  134.   return Data[loc];
  135. }
  136.  
  137. //
  138. //
  139. //
  140. string& TStringArray::operator [](int loc) const
  141. {
  142.   return Data[loc];
  143. }
  144.  
  145. //
  146. //
  147. //
  148. void TStringArray::ForEach(IterFunc iter, void* args)
  149. {
  150.   Data.ForEach(iter, args);
  151. }
  152.  
  153. //
  154. //
  155. //
  156. string* TStringArray::FirstThat(CondFunc cond, void* args) const
  157. {
  158.   return Data.FirstThat(cond, args);
  159. }
  160.  
  161. //
  162. //
  163. //
  164. string* TStringArray::LastThat(CondFunc cond, void* args) const
  165. {
  166.   return Data.LastThat(cond, args);
  167. }
  168.  
  169. //
  170. //
  171. //
  172. void TStringArray::Flush()
  173. {
  174.   Data.Flush();
  175. }
  176.  
  177. //----------------------------------------------------------------------------
  178.  
  179. //
  180. //
  181. //
  182. TIntArray::TIntArray(int upper, int lower, int delta)
  183. :
  184.   Data(upper, lower, delta)
  185. {
  186. }
  187.  
  188. //
  189. //
  190. //
  191. int TIntArray::LowerBound() const
  192. {
  193.   return Data.LowerBound();
  194. }
  195.  
  196. //
  197. //
  198. //
  199. int TIntArray::UpperBound() const
  200. {
  201.   return Data.UpperBound();
  202. }
  203.  
  204. //
  205. //
  206. //
  207. unsigned TIntArray::ArraySize() const
  208. {
  209.   return Data.ArraySize();
  210. }
  211.  
  212. //
  213. //
  214. //
  215. int TIntArray::IsFull() const
  216. {
  217.   return Data.IsFull();
  218. }
  219.  
  220. //
  221. //
  222. //
  223. int TIntArray::IsEmpty() const
  224. {
  225.   return Data.IsEmpty();
  226. }
  227.  
  228. //
  229. //
  230. //
  231. unsigned TIntArray::GetItemsInContainer() const
  232. {
  233.   return Data.GetItemsInContainer();
  234. }
  235.  
  236. //
  237. //
  238. //
  239. int TIntArray::Add(const TInt& t)
  240. {
  241.   return Data.Add(t);
  242. }
  243.  
  244. //
  245. //
  246. //
  247. int TIntArray::Detach(const TInt& t)
  248. {
  249.   return Data.Detach(t);
  250. }
  251.  
  252. //
  253. //
  254. //
  255. int TIntArray::Detach(int loc)
  256. {
  257.   return Data.Detach(loc);
  258. }
  259.  
  260. //
  261. //
  262. //
  263. int TIntArray::Destroy(const TInt& t)
  264. {
  265.   return Detach(t);
  266. }
  267.  
  268. //
  269. //
  270. //
  271. int TIntArray::Destroy(int loc)
  272. {
  273.   return Detach(loc);
  274. }
  275.  
  276. //
  277. //
  278. //
  279. int TIntArray::HasMember(const TInt& t) const
  280. {
  281.   return Data.HasMember(t);
  282. }
  283.  
  284. //
  285. //
  286. //
  287. int TIntArray::Find(const TInt& t) const
  288. {
  289.   return Data.Find(t);
  290. }
  291.  
  292. //
  293. //
  294. //
  295. TInt& TIntArray::operator [](int loc)
  296. {
  297.   return Data[loc];
  298. }
  299.  
  300. //
  301. //
  302. //
  303. TInt& TIntArray::operator [](int loc) const
  304. {
  305.   return Data[loc];
  306. }
  307.  
  308. //
  309. //
  310. //
  311. void TIntArray::ForEach(IterFunc iter, void* args)
  312. {
  313.   Data.ForEach(iter, args);
  314. }
  315.  
  316. //
  317. //
  318. //
  319. TInt* TIntArray::FirstThat(CondFunc cond, void* args) const
  320. {
  321.   return Data.FirstThat(cond, args);
  322. }
  323.  
  324. //
  325. //
  326. //
  327. TInt* TIntArray::LastThat(CondFunc cond, void* args) const
  328. {
  329.   return Data.LastThat(cond, args);
  330. }
  331.  
  332. //
  333. //
  334. //
  335. void TIntArray::Flush()
  336. {
  337.   Data.Flush();
  338. }
  339.  
  340. //----------------------------------------------------------------------------
  341.  
  342. //
  343. //
  344. //
  345. TUint32Array::TUint32Array(int upper, int lower, int delta)
  346. :
  347.   Data(upper, lower, delta)
  348. {
  349. }
  350.  
  351. //
  352. //
  353. //
  354. int TUint32Array::LowerBound() const
  355. {
  356.   return Data.LowerBound();
  357. }
  358.  
  359. //
  360. //
  361. //
  362. int TUint32Array::UpperBound() const
  363. {
  364.   return Data.UpperBound();
  365. }
  366.  
  367. //
  368. //
  369. //
  370. unsigned TUint32Array::ArraySize() const
  371. {
  372.   return Data.ArraySize();
  373. }
  374.  
  375. //
  376. //
  377. //
  378. int TUint32Array::IsFull() const
  379. {
  380.   return Data.IsFull();
  381. }
  382.  
  383. //
  384. //
  385. //
  386. int TUint32Array::IsEmpty() const
  387. {
  388.   return Data.IsEmpty();
  389. }
  390.  
  391. //
  392. //
  393. //
  394. unsigned TUint32Array::GetItemsInContainer() const
  395. {
  396.   return Data.GetItemsInContainer();
  397. }
  398.  
  399. //
  400. //
  401. //
  402. int TUint32Array::Add(const uint32& t)
  403. {
  404.   return Data.Add(t);
  405. }
  406.  
  407. //
  408. //
  409. //
  410. int TUint32Array::Detach(const uint32& t)
  411. {
  412.   return Data.Detach(t);
  413. }
  414.  
  415. //
  416. //
  417. //
  418. int TUint32Array::Detach(int loc)
  419. {
  420.   return Data.Detach(loc);
  421. }
  422.  
  423. //
  424. //
  425. //
  426. int TUint32Array::Destroy(const uint32& t)
  427. {
  428.   return Detach(t);
  429. }
  430.  
  431. //
  432. //
  433. //
  434. int TUint32Array::Destroy(int loc)
  435. {
  436.   return Detach(loc);
  437. }
  438.  
  439. //
  440. //
  441. //
  442. int TUint32Array::HasMember(const uint32& t) const
  443. {
  444.   return Data.HasMember(t);
  445. }
  446.  
  447. //
  448. //
  449. //
  450. int TUint32Array::Find(const uint32& t) const
  451. {
  452.   return Data.Find(t);
  453. }
  454.  
  455. //
  456. //
  457. //
  458. uint32& TUint32Array::operator [](int loc)
  459. {
  460.   return Data[loc];
  461. }
  462.  
  463. //
  464. //
  465. //
  466. uint32& TUint32Array::operator [](int loc) const
  467. {
  468.   return Data[loc];
  469. }
  470.  
  471. //
  472. //
  473. //
  474. void TUint32Array::ForEach(IterFunc iter, void* args)
  475. {
  476.   Data.ForEach(iter, args);
  477. }
  478.  
  479. //
  480. //
  481. //
  482. uint32* TUint32Array::FirstThat(CondFunc cond, void* args) const
  483. {
  484.   return Data.FirstThat(cond, args);
  485. }
  486.  
  487. //
  488. //
  489. //
  490. uint32* TUint32Array::LastThat(CondFunc cond, void* args) const
  491. {
  492.   return Data.LastThat(cond, args);
  493. }
  494.  
  495. //
  496. //
  497. //
  498. void TUint32Array::Flush()
  499. {
  500.   Data.Flush();
  501. }
  502.